﻿using System;
using Server.Items;
using System.Collections;
using System.Collections.Generic;
using Server.Commands;
using Server.Mobiles;
using Server.Targeting;
using Server.Network;

namespace Server.Engines.CastSystem
{
    public class Disarmare : Cast
    {
        public Disarmare(Mobile caster)
            : base(caster)
        {
        }

        public override bool DefFaPerdereIlColpo { get { return true; } }
        public override bool DefRichiedeTarget { get { return true; } }
        public override int DefMaxRange { get { return 2; } }
        public override CastType DefTipo { get { return CastType.Dannoso; } }

        // Ritorna true se il caster ha i requisiti per lanciare questo cast
        public override bool checkRequisiti()
        {
            if (DateTime.Now < Caster.DelayGenerale)
            {
                Caster.SendMessage("Delay generale");
                return false;
            }
            if (DateTime.Now < Caster.DelayRelativoDisarmare)
            {
                Caster.SendMessage("Delay relativo");
                return false;
            }

            return true;
        }

        // Non posso diarmare me stesso. 
        // Disarmare non costa nulla.
        public override bool OnBeforeCast(Mobile target)
        {
            // Non posso disarmare me stesso.
            if (target == Caster)
                return false;

            //else
                return true;
        }

        public override void OnCastTarget(Mobile target)
        {
            bool oneHanded = true;

            Item item = target.FindItemOnLayer(Layer.OneHanded);

            if (item == null)
            {
                oneHanded = false;
                item = target.FindItemOnLayer(Layer.TwoHanded);
            }

            // Il target ha un'arma in mano
            if (item != null && item is ArmaBase)
            {
                // Settiamo delay relativo (13 secondi) e generale (6 secondi)
                Caster.DelayGenerale = DateTime.Now + TimeSpan.FromSeconds(6);
                Caster.DelayRelativoDisarmare = DateTime.Now + TimeSpan.FromSeconds(13);

                // preso dal sito
                int chance = 16 + Caster.Livello - target.Livello;
                int chanceRange = (oneHanded) ? 29 : 44;

                if (chance > Utility.RandomMinMax(1, chanceRange))
                {
                    // Disarma l'avversario
                    if (target is PlayerMobile) // Un PG non puo reimpugnare l'arma per 13 secondi
                        target.DelayImpugnareArma = DateTime.Now + TimeSpan.FromSeconds(13);
                    else // Un NPG non puo reimpugnare l'arma per 6 secondi
                        target.DelayImpugnareArma = DateTime.Now + TimeSpan.FromSeconds(6);

                    target.RemoveItem(item);
                    target.AddToBackpack(item);

                    Caster.PublicOverheadMessage(MessageType.Regular, 0x400, false, Caster.Name + " disarma l'avversario");
                }
                else
                {
                    Caster.SendMessage("Non riesci a disarmare l'avversario.");
                }
            }
            else
            {
                Caster.SendMessage("Non puoi disarmare l'avversario.");
            }
        }
    }

    public class Intimidire : Cast
    {
        public Intimidire(Mobile caster)
            : base(caster)
        {
        }

        public override bool DefFaPerdereIlColpo { get { return true; } }
        public override bool DefRichiedeTarget { get { return true; } }
        public override int DefMaxRange { get { return 6; } }
        public override CastType DefTipo { get { return CastType.Dannoso; } }

        // Ritorna true se il caster ha i requisiti per lanciare questo cast
        public override bool checkRequisiti()
        {
            if (DateTime.Now < Caster.DelayGenerale)
            {
                Caster.SendMessage("Delay generale");
                return false;
            }

            return true;
        }

        public override bool OnBeforeCast(Mobile target)
        {
            // Non posso intimidire me stesso. 
            if (target == Caster)
                return false;

 	        // Consuma 8 punti stamina
            if (Caster.Stam < 8)
            {
                Caster.SendMessage("Non hai abbastanza stamina");
                return false;
            }
            else
            {
                Caster.Stam = Caster.Stam - 8;
                return true;
            }
        }

        public override void OnCastTarget(Mobile target)
        {
            // Delay generale 8 secondi
            Caster.DelayGenerale = DateTime.Now + TimeSpan.FromSeconds(8);

            // 120 secondi + livello
            TimeSpan durata = TimeSpan.FromSeconds(120 + Caster.Livello);

            CastSystem.RegisterCurseOrBless(target, this, durata, true);
           
            StatMod DexMalus = new StatMod(StatType.Dex, "MDA_Intimidire_Dex", -(Caster.Livello / 3), durata);
            StatMod IntMalus = new StatMod(StatType.Int, "MDA_Intimidire_Int", -(Caster.Livello / 3), durata);
            StatMod ForzaMalus = new StatMod(StatType.Forza, "MDA_Intimidire_Forza", -(Caster.Livello / 6), durata);

            target.AddStatMod(DexMalus);
            target.AddStatMod(IntMalus);
            target.AddStatMod(ForzaMalus);

            Caster.SendMessage("Intimidisci l'avversario");
            target.SendMessage(Caster.Name + " ti intimidisce");
        }
    }

    public class Maestria : Cast
    {
        public Maestria(Mobile caster)
            : base(caster)
        {
        }

        public override bool DefFaPerdereIlColpo { get { return true; } }
        public override bool DefRichiedeTarget { get { return true; } }
        public override int DefMaxRange { get { return 2; } }
        public override CastType DefTipo { get { return CastType.Dannoso; } }

        // Ritorna true se il caster ha i requisiti per lanciare questo cast
        public override bool checkRequisiti()
        {
            if (DateTime.Now < Caster.DelayGenerale)
            {
                Caster.SendMessage("Delay generale");
                return false;
            }
            if (DateTime.Now < Caster.DelayRelativoMaestria)
            {
                Caster.SendMessage("Delay relativo");
                return false;
            }

            return true;
        }

        public override bool OnBeforeCast(Mobile target)
        {
            // Non posso fare maestria su me stesso. 
            if (target == Caster)
                return false;

            // Non ho un'arma in mano
            if (Caster.Weapon == null)
            {
                Caster.SendMessage("Non stai impugnando un'arma");
                return false;
            }

            // Consuma 8 punti stamina
            if (Caster.Stam < 8)
            {
                Caster.SendMessage("Non hai abbastanza stamina");
                return false;
            }
            else
            {
                Caster.Stam = Caster.Stam - 8;
                return true;
            }
        }

        public override void OnCastTarget(Mobile target)
        {
            ArmaBase arma = (ArmaBase)Caster.Weapon;

            // Per sicurezza. In teoria abbiamo gia controllato che il Caster ha un'arma in mano.
            if (arma == null)
                return;

            // Delay generale 8 secondi
            Caster.DelayGenerale = DateTime.Now + TimeSpan.FromSeconds(8);
            // Delay relativo: 32 - Livello / 2
            Caster.DelayRelativoMaestria = DateTime.Now + TimeSpan.FromSeconds(32 - (Caster.Livello / 2));

            // Applica danno
            target.Damage(Caster.Livello, Caster);

            Caster.aggiornaDirezioneDuranteCaricaScarica(target, false);
            arma.PlaySwingAnimation(Caster, 0);
            Caster.SendMessage("Colpisci il bersaglio con un colpo da maestro");
            target.SendMessage(Caster.Name + " ti colpisce con un colpo da maestro");
        }
    }

    public class GranMaestria : Cast
    {
        public GranMaestria(Mobile caster)
            : base(caster)
        {
        }

        public override bool DefFaPerdereIlColpo { get { return true; } }
        public override bool DefRichiedeTarget { get { return true; } }
        public override int DefMaxRange { get { return 2; } }
        public override CastType DefTipo { get { return CastType.Dannoso; } }

        // Ritorna true se il caster ha i requisiti per lanciare questo cast
        public override bool checkRequisiti()
        {
            if (DateTime.Now < Caster.DelayGenerale)
            {
                Caster.SendMessage("Delay generale");
                return false;
            }

            if (DateTime.Now < Caster.DelayRelativoGranMaestria)
            {
                Caster.SendMessage("Delay relativo");
                return false;
            }

            return true;
        }

        public override bool OnBeforeCast(Mobile target)
        {
            // Non posso fare maestria su me stesso. 
            if (target == Caster)
                return false;

            // Non ho un'arma in mano
            if (Caster.Weapon == null)
            {
                Caster.SendMessage("Non stai impugnando un'arma");
                return false;
            }

            // Consuma 10 punti stamina
            if (Caster.Stam < 10)
            {
                Caster.SendMessage("Non hai abbastanza stamina");
                return false;
            }
            else
            {
                Caster.Stam = Caster.Stam - 10;
                return true;
            }
        }

        public override void OnCastTarget(Mobile target)
        {
            ArmaBase arma = (ArmaBase)Caster.Weapon;

            // Per sicurezza. In teoria abbiamo gia controllato che il Caster ha un'arma in mano.
            if (arma == null)
                return;

            // Delay generale 8 secondi
            Caster.DelayGenerale = DateTime.Now + TimeSpan.FromSeconds(8);
            // Delay relativo: 32 - Livello / 2
            Caster.DelayRelativoGranMaestria = DateTime.Now + TimeSpan.FromSeconds(32 - (Caster.Livello / 2));

            // Applica danno
            target.Damage(Caster.Livello - 10, Caster);
            target.Mana = target.Mana - (Caster.Livello - 10); 

            Caster.aggiornaDirezioneDuranteCaricaScarica(target, false);
            arma.PlaySwingAnimation(Caster, 0);
            Caster.SendMessage("Colpisci il bersaglio con un colpo da gran maestro");
            target.SendMessage(Caster.Name + " ti colpisce con un colpo da gran maestro");
        }
    }

    public class ColpoDiScudo : Cast
    {
        public ColpoDiScudo(Mobile caster)
            : base(caster)
        {
        }

        public override bool DefFaPerdereIlColpo { get { return true; } }
        public override bool DefRichiedeTarget { get { return true; } }
        public override int DefMaxRange { get { return 2; } }
        public override CastType DefTipo { get { return CastType.Dannoso; } }

        // Ritorna true se il caster ha i requisiti per lanciare questo cast
        public override bool checkRequisiti()
        {
            if (DateTime.Now < Caster.DelayGenerale)
            {
                Caster.SendMessage("Delay generale");
                return false;
            }

            if (DateTime.Now < Caster.DelayRelativoColpoDiScudo)
            {
                Caster.SendMessage("Delay relativo");
                return false;
            }

            return true;
        }

        public override bool OnBeforeCast(Mobile target)
        {
            // Non posso fare maestria su me stesso. 
            if (target == Caster)
                return false;

            // Non ho uno scudo in mano
            Item item = Caster.FindItemOnLayer(Layer.TwoHanded);
            if (item == null || !(item is ArmaturaBase))
            {
                Caster.SendMessage("Non stai impugnando uno scudo");
                return false;
            }

            // Consuma 30 punti stamina
            if (Caster.Stam < 30)
            {
                Caster.SendMessage("Non hai abbastanza stamina");
                return false;
            }
            else
            {
                Caster.Stam = Caster.Stam - 30;
                return true;
            }
        }

        public override void OnCastTarget(Mobile target)
        {
            // Delay generale 8 secondi
            Caster.DelayGenerale = DateTime.Now + TimeSpan.FromSeconds(8);
            // Delay relativo: 2 minuti
            Caster.DelayRelativoColpoDiScudo = DateTime.Now + TimeSpan.FromMinutes(2);

            // Applica danno
            target.Damage(10, Caster);
            
            // Paralizza per 2 secondi
            target.Paralyze(TimeSpan.FromSeconds(2));

            Caster.aggiornaDirezioneDuranteCaricaScarica(target, false);
            Caster.SendMessage("Stordisci il bersaglio con un colpo di scudo");
            target.SendMessage(Caster.Name + " ti stordisce con un colpo di scudo");
        }
    }

    public class ParataAdImpatto : Cast
    {
        ParataAdImpattoTimer timer;

        public ParataAdImpatto(Mobile caster)
            : base(caster)
        {
        }

        // Ritorna true se il caster ha i requisiti per lanciare questo cast
        public override bool checkRequisiti()
        {
            if (CastSystem.CurseOrBlessLookUp(Caster, GetType()))
            {
                Caster.SendMessage("Potere gia' attivo");
                return false;
            }

            if (DateTime.Now < Caster.DelayGenerale)
            {
                Caster.SendMessage("Delay generale");
                return false;
            }

            return true;
        }

        public override bool OnBeforeCast()
        {
            // Consuma 20 punti stamina
            if (Caster.Stam < 20)
            {
                Caster.SendMessage("Non hai abbastanza stamina");
                return false;
            }
            else
            {
                Caster.Stam = Caster.Stam - 20;
                return true;
            }
        }

        public override void OnCast()
        {
            // Delay generale 6 secondi
            Caster.DelayGenerale = DateTime.Now + TimeSpan.FromSeconds(6);

            Caster.SendMessage("Parata ad impatto attiva");

            CastSystem.RegisterCurseOrBless(Caster, this, TimeSpan.FromMinutes(4), false);

            // 4 minuti
            timer = new ParataAdImpattoTimer(Caster, TimeSpan.FromMinutes(4));
            timer.Start();
        }
    }

    public class ParataAdImpattoTimer : Timer
    {
        private Mobile m_Caster;

        public ParataAdImpattoTimer(Mobile from, TimeSpan castDelay)
            : base(castDelay)
        {
            m_Caster = from;

            Priority = TimerPriority.TwentyFiveMS;
        }

        // Quando scade il timer.
        protected override void OnTick()
        {
            m_Caster.SendMessage("Parata ad impatto terminata");
        }
    }

    public class Leggiadria : Cast
    {
        LeggiadriaTimer timer;

        public Leggiadria(Mobile caster)
            : base(caster)
        {
        }

        // Ritorna true se il caster ha i requisiti per lanciare questo cast
        public override bool checkRequisiti()
        {
            if (Caster.LeggiadriaAttiva)
            {
                Caster.SendMessage("Potere gia' attivo");
                return false;
            }

            if (DateTime.Now < Caster.DelayGenerale)
            {
                Caster.SendMessage("Delay generale");
                return false;
            }

            if (DateTime.Now < Caster.DelayRelativoLeggiadria)
            {
                Caster.SendMessage("Delay relativo");
                return false;
            }

            return true;
        }

        public override bool OnBeforeCast()
        {
            // Consuma 15 punti stamina
            if (Caster.Stam < 15)
            {
                Caster.SendMessage("Non hai abbastanza stamina");
                return false;
            }
            else
            {
                Caster.Stam = Caster.Stam - 15;
                return true;
            }
        }

        public override void OnCast()
        {
            // Delay generale 6 secondi
            Caster.DelayGenerale = DateTime.Now + TimeSpan.FromSeconds(6);

            // Delay relativo 6 minuti
            Caster.DelayRelativoLeggiadria = DateTime.Now + TimeSpan.FromMinutes(6);

            Caster.SendMessage("Leggiadria attiva");

            Caster.LeggiadriaAttiva = true;
            // 3 minuti
            timer = new LeggiadriaTimer(Caster, TimeSpan.FromMinutes(3));
            timer.Start();
        }
    }

    public class LeggiadriaTimer : Timer
    {
        private Mobile m_Caster;

        public LeggiadriaTimer(Mobile from, TimeSpan castDelay)
            : base(castDelay)
        {
            m_Caster = from;

            Priority = TimerPriority.FiftyMS;
        }

        // Quando scade il timer.
        protected override void OnTick()
        {
            m_Caster.SendMessage("Leggiadria terminata");
            m_Caster.LeggiadriaAttiva = false;
        }
    }

    public class SignoreDellaGuerra : Cast
    {
        public SignoreDellaGuerra(Mobile caster)
            : base(caster)
        {
        }

        public override bool DefFaPerdereIlColpo { get { return true; } }
        public override bool DefCastAdArea { get { return true; } }
        public override int DefMaxRange { get { return 1; } }
        public override CastType DefTipo { get { return CastType.Dannoso; } }

        // Ritorna true se il caster ha i requisiti per lanciare questo cast
        public override bool checkRequisiti()
        {
            if (DateTime.Now < Caster.DelayGenerale)
            {
                Caster.SendMessage("Delay generale");
                return false;
            }

            if (DateTime.Now < Caster.DelayRelativoSignoreDellaGuerra)
            {
                Caster.SendMessage("Delay relativo");
                return false;
            }

            return true;
        }

        public override bool OnBeforeCast()
        {
            // Non ho un'arma a due mani in mano
            Item item = Caster.FindItemOnLayer(Layer.TwoHanded);
            if (item == null || !(item is ArmaBase))
            {
                Caster.SendMessage("Non stai impugnando un'arma a due mani");
                return false;
            }

            // Consuma 30 punti stamina
            if (Caster.Stam < 30)
            {
                Caster.SendMessage("Non hai abbastanza stamina");
                return false;
            }
            else
            {
                Caster.Stam = Caster.Stam - 30;
            }

            // Delay generale 6 secondi
            Caster.DelayGenerale = DateTime.Now + TimeSpan.FromSeconds(8);
            // Delay relativo: 10 minuti
            Caster.DelayRelativoSignoreDellaGuerra = DateTime.Now + TimeSpan.FromMinutes(10);

            // Paralizza per il caster per 1 secondo
            Caster.Paralyze(TimeSpan.FromSeconds(1));

            Caster.SendMessage("Il colpo sferrato ti disorienta");

            return true;
        }

        public override void OnCastTarget(Mobile target)
        {
            if (target == Caster)
                return;

            // Applica danno
            target.Damage(Caster.Livello / 2, Caster);

            // Paralizza per il target per 3 secondi
            target.Paralyze(TimeSpan.FromSeconds(1));

            target.SendMessage(Caster.Name + " ti stordisce con un colpo");
        }
    }

    public class StileMDA : Cast
    {
        public StileMDA(Mobile caster)
            : base(caster)
        {
        }
        // Difensivo
        protected static DefaultSkillMod m_DifensivoParare;
        protected static StatMod m_DifensivoForza;
        // Aggressivo
        protected static DefaultSkillMod m_AggressivoLottare;
        protected static DefaultSkillMod m_AggressivoPunta;
        protected static DefaultSkillMod m_AggressivoTaglio;
        protected static DefaultSkillMod m_AggressivoContundenti;
        protected static StatMod m_AggressivoForza;
        // Irruento
        protected static DefaultSkillMod m_IrruentoLottare;
        protected static DefaultSkillMod m_IrruentoPunta;
        protected static DefaultSkillMod m_IrruentoTaglio;
        protected static DefaultSkillMod m_IrruentoContundenti;
        protected static DefaultSkillMod m_IrruentoParare;
        protected static StatMod m_IrruentoForza;
        // Accurato
        protected static DefaultSkillMod m_AccuratoLottare;
        protected static DefaultSkillMod m_AccuratoPunta;
        protected static DefaultSkillMod m_AccuratoTaglio;
        protected static DefaultSkillMod m_AccuratoContundenti;
        protected static StatMod m_AccuratoForza;

        public static void Initialize()
        {
            // Mods Stile Difensivo
            m_DifensivoParare = new DefaultSkillMod(SkillName.Parry, true, 15.0);
            m_DifensivoForza = new StatMod(StatType.Forza, "MDA_StileDifensivo_Forza", -6, TimeSpan.Zero);

            // Mods Stile Aggressivo
            m_AggressivoLottare = new DefaultSkillMod(SkillName.Wrestling, true, -6.0);
            m_AggressivoPunta = new DefaultSkillMod(SkillName.Fencing, true, -6.0);
            m_AggressivoTaglio = new DefaultSkillMod(SkillName.Swords, true, -6.0);
            m_AggressivoContundenti = new DefaultSkillMod(SkillName.Macing, true, -6.0);
            m_AggressivoForza = new StatMod(StatType.Forza, "MDA_StileAggressivo_Forza", 8, TimeSpan.Zero);

            // Mods Stile Irruento
            m_IrruentoLottare = new DefaultSkillMod(SkillName.Wrestling, true, -3.0);
            m_IrruentoPunta = new DefaultSkillMod(SkillName.Fencing, true, -3.0);
            m_IrruentoTaglio = new DefaultSkillMod(SkillName.Swords, true, -3.0);
            m_IrruentoContundenti = new DefaultSkillMod(SkillName.Macing, true, -3.0);
            m_IrruentoParare = new DefaultSkillMod(SkillName.Parry, true, -20.0);
            m_IrruentoForza = new StatMod(StatType.Forza, "MDA_StileIrruento_Forza", 3, TimeSpan.Zero);

            // Mods Stile Accurato
            m_AccuratoLottare = new DefaultSkillMod(SkillName.Wrestling, true, 6.0);
            m_AccuratoPunta = new DefaultSkillMod(SkillName.Fencing, true, 6.0);
            m_AccuratoTaglio = new DefaultSkillMod(SkillName.Swords, true, 6.0);
            m_AccuratoContundenti = new DefaultSkillMod(SkillName.Macing, true, 6.0);
            m_AccuratoForza = new StatMod(StatType.Forza, "MDA_StileAccurato_Forza", -3, TimeSpan.Zero);

        }


        public override double DefTempoDiRecitazione { get { return 0.0; } }
        public override double DefTempoDiColpoInCanna { get { return 0.0; } }
        public override bool DefFaPerdereIlColpo { get { return false; } }
        public override bool DefRichiedeTarget { get { return false; } }
        public override int DefMaxRange { get { return 0; } }

        public void RimuoviMods()
        {
            Caster.RemoveStatMod("MDA_StileDifensivo_Forza");
            Caster.RemoveStatMod("MDA_StileAggressivo_Forza");
            Caster.RemoveStatMod("MDA_StileIrruento_Forza");
            Caster.RemoveStatMod("MDA_StileAccurato_Forza");

            Caster.RemoveSkillMod(m_DifensivoParare);

            Caster.RemoveSkillMod(m_AggressivoLottare);
            Caster.RemoveSkillMod(m_AggressivoPunta);
            Caster.RemoveSkillMod(m_AggressivoTaglio);
            Caster.RemoveSkillMod(m_AggressivoContundenti);

            Caster.RemoveSkillMod(m_IrruentoLottare);
            Caster.RemoveSkillMod(m_IrruentoPunta);
            Caster.RemoveSkillMod(m_IrruentoTaglio);
            Caster.RemoveSkillMod(m_IrruentoContundenti);
            Caster.RemoveSkillMod(m_IrruentoParare);

            Caster.RemoveSkillMod(m_AccuratoLottare);
            Caster.RemoveSkillMod(m_AccuratoPunta);
            Caster.RemoveSkillMod(m_AccuratoTaglio);
            Caster.RemoveSkillMod(m_AccuratoContundenti);
        }
    }

    public class StileNormale : StileMDA
    {
        public StileNormale(Mobile caster)
            : base(caster)
        {
        }

        public override void OnCast()
        {
            if (Caster.HasSkillMod(m_DifensivoParare) || Caster.HasSkillMod(m_AggressivoLottare) || Caster.HasSkillMod(m_IrruentoLottare) || Caster.HasSkillMod(m_AccuratoLottare))
            {
                Caster.SendMessage("Torni ad uno stile *NORMALE*");
                RimuoviMods();
            }
            else
            {
                Caster.SendMessage("Stai gia adottando uno stile *NORMALE*");
            }

        }
    }

    public class StileDifensivo : StileMDA
    {
        public StileDifensivo(Mobile caster)
            : base(caster)
        {
        }

        public override void OnCast()
        {
            if (Caster.HasSkillMod(m_DifensivoParare))
            {
                Caster.SendMessage("Stai gia adottando uno stile *DIFENSIVO*");
            }
            else
            {
                RimuoviMods();
                Caster.AddSkillMod(m_DifensivoParare);
                Caster.AddStatMod(m_DifensivoForza);
                Caster.SendMessage("Adotti uno stile *DIFENSIVO*");
            }
        }
    }

    public class StileAggressivo : StileMDA
    {
        public StileAggressivo(Mobile caster)
            : base(caster)
        {
        }

        public override void OnCast()
        {
            if (Caster.HasSkillMod(m_AggressivoLottare))
            {
                Caster.SendMessage("Stai gia adottando uno stile *AGGRESSIVO*");
            }
            else
            {
                RimuoviMods();
                Caster.AddSkillMod(m_AggressivoLottare);
                Caster.AddSkillMod(m_AggressivoPunta);
                Caster.AddSkillMod(m_AggressivoTaglio);
                Caster.AddSkillMod(m_AggressivoContundenti);
                Caster.AddStatMod(m_AggressivoForza);
                Caster.SendMessage("Adotti uno stile *AGGRESSIVO*");
            }
        }
    }

    public class StileIrruento : StileMDA
    {
        public StileIrruento(Mobile caster)
            : base(caster)
        {
        }

        public override void OnCast()
        {
            if (Caster.HasSkillMod(m_IrruentoLottare))
            {
                Caster.SendMessage("Stai gia adottando uno stile *IRRUENTO*");
            }
            else
            {
                RimuoviMods();
                Caster.AddSkillMod(m_IrruentoLottare);
                Caster.AddSkillMod(m_IrruentoPunta);
                Caster.AddSkillMod(m_IrruentoTaglio);
                Caster.AddSkillMod(m_IrruentoContundenti);
                Caster.AddSkillMod(m_IrruentoParare);
                Caster.AddStatMod(m_IrruentoForza);
                Caster.SendMessage("Adotti uno stile *IRRUENTO*");
            }
        }
    }

    public class StileAccurato : StileMDA
    {
        public StileAccurato(Mobile caster)
            : base(caster)
        {
        }

        public override void OnCast()
        {
            if (Caster.HasSkillMod(m_AccuratoLottare))
            {
                Caster.SendMessage("Stai gia adottando uno stile *ACCURATO*");
            }
            else
            {
                RimuoviMods();
                Caster.AddSkillMod(m_AccuratoLottare);
                Caster.AddSkillMod(m_AccuratoPunta);
                Caster.AddSkillMod(m_AccuratoTaglio);
                Caster.AddSkillMod(m_AccuratoContundenti);
                Caster.AddStatMod(m_AccuratoForza);
                Caster.SendMessage("Adotti uno stile *ACCURATO*");
            }
        }
    }
}
